
#include <unordered_map>
#include <vector>
#include<iostream>
#include <thread>










//    几个需要注意的点
/*
1.  c++的list虽然是双向链表实现的，但是并不支持  得到某个node后，既能查找前面一个node，也能查找后面一个node  需要找一个库  用list迭代器就可以实现  进一步考虑	
	是否可使用入侵式容器
2  thread 如果要跑manager里面的run方法  注意参数的传递
3  两个struct 有相互引用的情况  以实例方式声明会出问题  改用智能指针，默认用unique_ptr  在struct 构造的时候应当删除 默认构造函数  自定义的构造函数应传入指针指向的内存  

*/
using namespace std;

struct RoutineIndex;
struct  Unit
{
	int Id;
	bool Direction;// 1  规定正向 index  小-- >> 大
	shared_ptr<RoutineIndex> OffIndex;//下车站点
};

struct RoutineIndex
{
	int Number;
	int DurationTime;  // 正向 111
	int uDurationTime;  // 逆向 
	unordered_map<int, Unit> UnitContainer;  //站点要上车人数
	RoutineIndex(int num,int durationTime):Number(num),DurationTime(durationTime), uDurationTime(durationTime)
	{
	}
};

struct CarElement
{

	shared_ptr<RoutineIndex>    CurrIndex; //当前行驶站点
	int CurrUnitNum; //当前载客量
	int MaxLoad; //最大载客量
	int ExecMinNum; //总行驶时间
	int PassedMinNum; //总运行时间
	bool Direction;// Direction为1 时    规定正向 index  小-->>大
	unordered_map<int, Unit> UnitContainer;  //车运行时实际正在载客的数量
	CarElement(bool drct,int maxnum):Direction(drct), MaxLoad(maxnum)
	,ExecMinNum(0)
	,CurrUnitNum (0)
	,PassedMinNum (0)
	{
	}
};

/*

1.初始化 routine  主要初始化两个routine 之间的距离
2.在Routine 首先产生 unit  然后开始向两端调度car  即就是隔一段时间初始化两个car  直到总公交车数量为0   
3.每个car首先处理当前站点的上车下车情况  然后根据当前站点到下一个站点的时间  睡眠这个时间的大小  之后公交车到下个站点 处理上车下车  判断到站尾了  则逆向行驶  

*/
class CarMananger
{
public:
	CarMananger(int carnum,int totalIndexNum,vector<int> rt,int perloadnum,int stop):m_CarNum(carnum),
																					m_CarLoadNum(perloadnum)
	{
		InitRoutine();
		RandomUnit(); 
		ScheduleCar();
	}
static	void InitRoutine() //初始化公交路线
	{
		if (m_Routine.size() != m_RoutineDuration.size())
		{
			cout << "InitRoutine  Exeption " << endl;
			return;
		}
		for (int i=0;i<m_TotalIndexNum-1;i++)
		{
			RoutineIndex curr(i, m_RoutineDuration[i]);
			m_Routine.push_back(curr);
		}
	}
	void ScheduleCar()
	{
		CarElement temp1(0, m_CarLoadNum);
		temp1.CurrIndex.reset(&m_Routine[0]);
		CarElement temp2(1, m_CarLoadNum);
		temp2.CurrIndex.reset(&m_Routine[m_Routine.size()-1]);
		m_ExecCar.push_back(temp1);

		thread t1(&CarMananger::CarRun, ref(m_ExecCar.back()));
		t1.detach();

		m_ExecCar.push_back(temp2);
		thread t2(&CarMananger::CarRun, ref(m_ExecCar.back()));
		t2.detach();

		thread t3(&CarMananger::CarRunNoStatic, this,ref(m_ExecCar.back()));
		t3.detach();
	}
	 
	void CarRunNoStatic(CarElement &car)
	{

	}
	
	void RandomUnit() //在各个路线随机上车人数
	{
	 
	}
static	void CarRun(CarElement &car) //公交车执行过程
	{
		while (true)
		{
			if (car.PassedMinNum == m_stopTime)
			{
				break;
			}
			
			if (car.CurrIndex->Number == m_Routine.size() - 1) //逆向起始点
			{

			}
			if (car.CurrIndex->Number == 0 &&car.Direction==1)//正向起始点
			{
			

				this_thread::sleep_for(std::chrono::seconds(car.CurrIndex->DurationTime));
			}

		}
	}
private:
	int m_start;//CarManager 初始时间
	int m_CarNum; //总公交车数量
	int m_CarLoadNum;
static	int m_stopTime;//car每天运行累计时长后停止
static	vector<RoutineIndex> m_Routine; //公交站点路线
static	vector<int>m_RoutineDuration;
vector<CarElement> m_ExecCar;  //正在运行的公交车数量
static	int m_TotalIndexNum;                            //站点数量
};

int CarMananger::m_stopTime = 300;
int CarMananger::m_TotalIndexNum = 25;





#include <map>
#include <sstream>

struct test2
{
	int a;
	test2() = delete;
	test2(int aa):a(aa)
	{
	}

};
int main()
{
	

	auto cmp = [](const string &a,const string &b) {
		stringstream ss;
		ss << a;
		double aa = 0;
		double bb = 0;
		ss >>aa;
		ss.clear();
		ss << b;
		ss >> bb;
		return aa > bb;                       };
	map<string, int,decltype(cmp)> mymap(cmp);
	mymap["21.2"] = 2;
	mymap["21.4"] = 3;
	mymap["111.2"] = 4;
	mymap["9.2"] = 1;
	int d = 1;
	return 0;
}